AmigActive 10/AACD 10.iso/AACD/Games/WarpQuake/Src/sys_wind.c

C/C++ Source or Header | 2000-05-22 | 5KB | 326 lines

/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// sys_null.h -- null system driver to aid porting efforts

#include "quakedef.h"
#include "winquake.h"
#include "errno.h"
#include <sys\types.h>
#include <sys\timeb.h>


/*
===============================================================================

FILE IO

===============================================================================
*/

#define    MAX_HANDLES        10
FILE    *sys_handles[MAX_HANDLES];

int        findhandle (void)
{
    int        i;

    for (i=1 ; i<MAX_HANDLES ; i++)
        if (!sys_handles[i])
            return i;
    Sys_Error ("out of handles");
    return -1;
}

/*
================
filelength
================
*/
int filelength (FILE *f)
{
    int        pos;
    int        end;

    pos = ftell (f);
    fseek (f, 0, SEEK_END);
    end = ftell (f);
    fseek (f, pos, SEEK_SET);

    return end;
}

int Sys_FileOpenRead (char *path, int *hndl)
{
    FILE    *f;
    int        i;

    i = findhandle ();

    f = fopen(path, "rb");
    if (!f)
    {
        *hndl = -1;
        return -1;
    }
    sys_handles[i] = f;
    *hndl = i;

    return filelength(f);
}

int Sys_FileOpenWrite (char *path)
{
    FILE    *f;
    int        i;

    i = findhandle ();

    f = fopen(path, "wb");
    if (!f)
        Sys_Error ("Error opening %s: %s", path,strerror(errno));
    sys_handles[i] = f;

    return i;
}

void Sys_FileClose (int handle)
{
    fclose (sys_handles[handle]);
    sys_handles[handle] = NULL;
}

void Sys_FileSeek (int handle, int position)
{
    fseek (sys_handles[handle], position, SEEK_SET);
}

int Sys_FileRead (int handle, void *dest, int count)
{
    return fread (dest, 1, count, sys_handles[handle]);
}

int Sys_FileWrite (int handle, void *data, int count)
{
    return fwrite (data, 1, count, sys_handles[handle]);
}

int    Sys_FileTime (char *path)
{
    FILE    *f;

    f = fopen(path, "rb");
    if (f)
    {
        fclose(f);
        return 1;
    }

    return -1;
}

void Sys_mkdir (char *path)
{
}


/*
===============================================================================

SYSTEM IO

===============================================================================
*/

void Sys_MakeCodeWriteable (unsigned long startaddr, unsigned long length)
{
}


void Sys_DebugLog(char *file, char *fmt, ...)
{
}

void Sys_Error (char *error, ...)
{
    va_list        argptr;
    char        text[1024];

    va_start (argptr,error);
    vsprintf (text, error,argptr);
    va_end (argptr);

//    MessageBox(NULL, text, "Error", 0 /* MB_OK */ );
    printf ("ERROR: %s\n", text);

    exit (1);
}

void Sys_Printf (char *fmt, ...)
{
    va_list        argptr;

    va_start (argptr,fmt);
    vprintf (fmt,argptr);
    va_end (argptr);
}

void Sys_Quit (void)
{
    exit (0);
}

double Sys_FloatTime (void)
{
    double t;
    struct _timeb tstruct;
    static int    starttime;

    _ftime( &tstruct );

    if (!starttime)
        starttime = tstruct.time;
    t = (tstruct.time-starttime) + tstruct.millitm*0.001;

    return t;
}

void Sys_Sleep (void)
{
}


void Sys_SendKeyEvents (void)
{
}

void Sys_HighFPPrecision (void)
{
}

void Sys_LowFPPrecision (void)
{
}

char *Sys_ConsoleInput (void)
{
    static char    text[256];
    static int        len;
    INPUT_RECORD    recs[1024];
    int        count;
    int        i;
    int        c;

    // read a line out
    while (_kbhit())
    {
        c = _getch();
        putch (c);
        if (c == '\r')
        {
            text[len] = 0;
            putch ('\n');
            len = 0;
            return text;
        }
        if (c == 8)
        {
            putch (' ');
            putch (c);
            len--;
            text[len] = 0;
            continue;
        }
        text[len] = c;
        len++;
        text[len] = 0;
        if (len == sizeof(text))
            len = 0;
    }

    return NULL;
}



/*
==================
main

==================
*/
char    *newargv[256];

int main (int argc, char **argv)
{
    MSG        msg;
    quakeparms_t    parms;
    double            time, oldtime;
    static    char    cwd[1024];

    memset (&parms, 0, sizeof(parms));

    parms.memsize = 16384*1024;
    parms.membase = malloc (parms.memsize);

    _getcwd (cwd, sizeof(cwd));
    if (cwd[Q_strlen(cwd)-1] == '\\')
        cwd[Q_strlen(cwd)-1] = 0;
    parms.basedir = cwd; //"f:/quake";
//    parms.basedir = "f:\\quake";

    COM_InitArgv (argc, argv);

    // dedicated server ONLY!
    if (!COM_CheckParm ("-dedicated"))
    {
        memcpy (newargv, argv, argc*4);
        newargv[argc] = "-dedicated";
        argc++;
        argv = newargv;
        COM_InitArgv (argc, argv);
    }

    parms.argc = argc;
    parms.argv = argv;

    printf ("Host_Init\n");
    Host_Init (&parms);

    oldtime = Sys_FloatTime ();

    /* main window message loop */
    while (1)
    {
        time = Sys_FloatTime();
        if (time - oldtime < sys_ticrate.value )
        {
            Sleep(1);
            continue;
        }

        Host_Frame ( time - oldtime );
        oldtime = time;
    }

    /* return success of application */
    return TRUE;
}